// const QQMapWX = require('../../js/qqmap-wx-jssdk.js');

Page({
  data: {
    // 传感器数据
    sensorData: {
      Speed: 0,
      Latitude: 39.9042,
      Longitude: 116.4074,
      Temperature: 0,
      Humidity: 0,
      GasConcentration: 0,
      analogValue: 0
    },
    
    // 地图相关
    currentLocation: {
      latitude: 39.9042,
      longitude: 116.4074
    },
    mapScale: 16,
    markers: [],
    polyline: [],
    hasMapPermission: false,
    currentAddress: '获取位置中...',
    
    // 轨迹数据
    trackPoints: [],        // 所有轨迹点
    recentPoints: [],       // 最近的轨迹点（用于绘制路线）
    maxTrackPoints: 1000,   // 最大保存轨迹点数
    maxPolylinePoints: 100, // 最大显示路线点数
    
    // 状态信息
    mqttConnected: false,
    hasWarnings: false,
    trackingActive: true,
    currentTime: '',
    
    // 地图SDK
    qqmapsdk: null,
    
    // 统计数据
    totalDistance: 0,       // 总行驶距离（米）
    trackingDuration: 0,   // 追踪时长（分钟）
    startTime: null,       // 开始时间
    
    // 车辆模拟状态（为了WXML绑定）
    vehicleSimulation: {
      isMoving: false,
      currentRouteIndex: 0,
      totalPoints: 0
    },
    speedText: '普通速度'
  },

  onLoad() {
    console.log('地图页面加载');
    this.initializeMap();
    this.initMqtt();
    this.updateTime();
    this.startTimeTimer();
    this.startTracking();
  },

  onShow() {
    console.log('地图页面显示');
    // 同步App全局的MQTT连接状态
    const app = getApp();
    this.setData({
      mqttConnected: app.globalData.mqttConnected
    });
    this.updateTime();
    
    // 确保回调已注册（处理页面切换时的重新注册）
    if (app.globalData.mqttClient) {
      app.registerPageDataCallback('map', (data) => {
        console.log('Map页面收到MQTT数据:', data);
        this.updateSensorData(data);
      });
      
      app.registerPageConnectionCallback('map', (connected) => {
        console.log('Map页面MQTT连接状态:', connected);
        this.setData({
          mqttConnected: connected
        });
      });
    }
  },

  onHide() {
    console.log('地图页面隐藏');
  },

  onUnload() {
    console.log('地图页面卸载');
    this.cleanup();
    
    // 注销页面回调
    const app = getApp();
    app.unregisterPageCallbacks('map');
  },

  // 初始化地图
  initializeMap() {
    // 暂时注释掉腾讯地图SDK，避免babel错误
    // this.data.qqmapsdk = new QQMapWX({
    //   key: 'SQCBZ-6F7KA-3EZKW-C5C4Z-IMGCO-WXBUZ'
    // });
    
    this.checkMapPermission();
    this.setupInitialMap();
  },

  // 初始化MQTT连接
  initMqtt() {
    // 使用App全局的MQTT客户端
    const app = getApp();
    if (app.globalData.mqttClient) {
      this.setData({
        mqttConnected: app.globalData.mqttConnected
      });
      
      // 注册到App的数据分发系统
      app.registerPageDataCallback('map', (data) => {
        console.log('Map页面收到MQTT数据:', data);
        this.updateSensorData(data);
      });
      
      app.registerPageConnectionCallback('map', (connected) => {
        console.log('Map页面MQTT连接状态:', connected);
        this.setData({
          mqttConnected: connected
        });
      });
    }
  },

  // 更新传感器数据
  updateSensorData(data) {
    if (!data || typeof data !== 'object') {
      return;
    }

    console.log('Map页面接收到的原始数据:', data);

    // 格式化数据
    const formattedData = {};
    Object.keys(this.data.sensorData).forEach(key => {
      if (data.hasOwnProperty(key)) {
        if (typeof data[key] === 'number') {
          formattedData[key] = Number(data[key].toFixed(4));
        } else {
          formattedData[key] = data[key];
        }
      }
    });

    console.log('Map页面格式化后的数据:', formattedData);

    // 更新传感器数据
    this.setData({
      sensorData: { ...this.data.sensorData, ...formattedData }
    });

    // 处理位置数据
    if (data.Latitude !== undefined && data.Longitude !== undefined) {
      console.log('=== 开始处理位置数据 ===');
      console.log('原始位置数据:', { Latitude: data.Latitude, Longitude: data.Longitude, Speed: data.Speed });
      
      // 验证坐标值的合理性
      let latitude = Number(data.Latitude);
      let longitude = Number(data.Longitude);
      
      console.log('转换后的数值:', { latitude, longitude });
      
      // 如果坐标值过大，可能需要转换（除以1000000等）
      if (Math.abs(latitude) > 90) {
        console.warn('纬度值异常，可能需要转换:', latitude);
        // 尝试转换为正常坐标范围
        if (latitude > 1000) {
          latitude = latitude / 1000000; // 假设是微度格式
          console.log('纬度转换后:', latitude);
        }
      }
      
      if (Math.abs(longitude) > 180) {
        console.warn('经度值异常，可能需要转换:', longitude);
        if (longitude > 1000) {
          longitude = longitude / 1000000; // 假设是微度格式
          console.log('经度转换后:', longitude);
        }
      }
      
      // 如果还是不合理，使用默认的北京坐标进行模拟
      if (Math.abs(latitude) > 90 || Math.abs(longitude) > 180) {
        console.warn('坐标值仍然异常，使用模拟坐标');
        // 使用北京附近的坐标，并添加小幅随机偏移模拟移动
        latitude = 39.9042 + (Math.random() - 0.5) * 0.01;
        longitude = 116.4074 + (Math.random() - 0.5) * 0.01;
        console.log('使用模拟坐标:', { latitude, longitude });
      }
      
      console.log('最终处理后的坐标:', { latitude, longitude, speed: data.Speed });
      
      const trackPoint = {
        latitude: latitude,
        longitude: longitude,
        speed: data.Speed || 0,
        timestamp: Date.now()
      };
      
      console.log('准备添加轨迹点:', trackPoint);
      this.addTrackPoint(trackPoint);
      
      // 更新当前位置
      console.log('更新当前位置到:', { latitude, longitude });
      this.setData({
        currentLocation: {
          latitude: latitude,
          longitude: longitude
        }
      });
      
      // 逆地址解析
      this.reverseGeocoding(latitude, longitude);
      console.log('=== 位置数据处理完成 ===');
    } else {
      console.log('位置数据不完整或缺失:', { Latitude: data.Latitude, Longitude: data.Longitude });
    }

    // 检查警告状态
    this.checkWarnings();
  },

  // 添加轨迹点
  addTrackPoint(point) {
    if (!this.data.trackingActive) {
      console.log('轨迹追踪未激活，跳过添加轨迹点');
      return;
    }

    console.log('=== 开始添加轨迹点 ===');
    console.log('新轨迹点:', point);
    console.log('当前追踪状态:', this.data.trackingActive);
    console.log('当前轨迹点数量:', this.data.trackPoints.length);

    const { trackPoints, recentPoints, maxTrackPoints, maxPolylinePoints } = this.data;
    
    // 添加到轨迹点数组
    const newTrackPoints = [...trackPoints, point];
    if (newTrackPoints.length > maxTrackPoints) {
      newTrackPoints.shift(); // 移除最旧的点
    }

    // 更新最近点数组（用于绘制路线）
    const newRecentPoints = [...recentPoints, point];
    if (newRecentPoints.length > maxPolylinePoints) {
      newRecentPoints.shift();
    }

    console.log('轨迹点数组更新:', {
      总轨迹点: newTrackPoints.length,
      显示轨迹点: newRecentPoints.length,
      最新点: point
    });

    // 计算距离和统计
    this.calculateTrackingStats(newTrackPoints);

    // 更新地图标记和路线
    this.updateMapMarkersAndPolyline(point, newRecentPoints);

    // 更新数据
    this.setData({
      trackPoints: newTrackPoints,
      recentPoints: newRecentPoints
    });
    
    console.log('轨迹点添加完成，新的总数:', newTrackPoints.length);
    console.log('=== 轨迹点添加结束 ===');
  },

  // 计算轨迹统计
  calculateTrackingStats(points) {
    // 如果还没有开始时间，设置为当前时间
    if (!this.data.startTime) {
      this.setData({
        startTime: Date.now()
      });
    }
    
    if (points.length < 2) {
      // 即使没有足够的点，也要更新持续时间
      const duration = this.data.startTime ? 
        Math.floor((Date.now() - this.data.startTime) / 60000) : 0;
      
      this.setData({
        totalDistance: 0,
        trackingDuration: Math.max(0, duration)
      });
      return;
    }

    let totalDistance = 0;
    
    for (let i = 1; i < points.length; i++) {
      const prev = points[i - 1];
      const curr = points[i];
      
      // 计算两点间距离（米）
      const distance = this.calculateDistance(
        prev.latitude, prev.longitude,
        curr.latitude, curr.longitude
      );
      totalDistance += distance;
    }

    const duration = this.data.startTime ? 
      Math.floor((Date.now() - this.data.startTime) / 60000) : 0;

    this.setData({
      totalDistance: Math.round(totalDistance),
      trackingDuration: Math.max(0, duration)
    });
  },

  // 计算两点间距离（米）
  calculateDistance(lat1, lon1, lat2, lon2) {
    const R = 6371000; // 地球半径（米）
    const dLat = (lat2 - lat1) * Math.PI / 180;
    const dLon = (lon2 - lon1) * Math.PI / 180;
    const a = Math.sin(dLat/2) * Math.sin(dLat/2) +
              Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) *
              Math.sin(dLon/2) * Math.sin(dLon/2);
    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
    return R * c;
  },

  // 更新地图标记和路线
  updateMapMarkersAndPolyline(currentPoint, recentPoints) {
    console.log('更新地图标记和路线:', {
      currentPoint,
      recentPointsCount: recentPoints.length
    });

    // 创建当前位置标记
    const markers = [{
      id: 1,
      latitude: currentPoint.latitude,
      longitude: currentPoint.longitude,
      iconPath: '/images/xiaoche.png', // 使用小车图标
      width: 30,
      height: 30,
      anchor: { x: 0.5, y: 0.5 },
      label: {
        content: `${Math.round(currentPoint.speed)} km/h`,
        fontSize: 12,
        color: '#333333',
        bgColor: '#ffffff',
        borderRadius: 4,
        padding: 4
      }
    }];

    // 创建轨迹路线
    const polyline = recentPoints.length > 1 ? [{
      points: recentPoints.map(point => ({
        latitude: point.latitude,
        longitude: point.longitude
      })),
      color: this.data.hasWarnings ? '#ff4d4f' : '#1677ff',
      width: 4,
      arrowLine: true,
      borderColor: '#ffffff',
      borderWidth: 1
    }] : [];

    console.log('地图更新数据:', {
      markers,
      polylineCount: polyline.length,
      polylinePoints: polyline.length > 0 ? polyline[0].points.length : 0
    });

    this.setData({
      markers,
      polyline
    });
  },

  // 检查警告状态
  checkWarnings() {
    const { sensorData } = this.data;
    
    // 简单的警告逻辑（可根据需要调整）
    const hasWarnings = 
      sensorData.Temperature > 35 ||
      sensorData.GasConcentration > 100 ||
      sensorData.analogValue > 500;

    this.setData({ hasWarnings });
  },

  // 检查地图权限
  checkMapPermission() {
    wx.getSetting({
      success: (res) => {
        if (res.authSetting['scope.userLocation']) {
          this.setData({ hasMapPermission: true });
          this.getCurrentLocation();
        } else {
          this.setData({ hasMapPermission: false });
          this.reverseGeocoding(
            this.data.currentLocation.latitude,
            this.data.currentLocation.longitude
          );
        }
      },
      fail: () => {
        this.setData({ hasMapPermission: false });
      }
    });
  },

  // 获取当前位置
  getCurrentLocation() {
    wx.getLocation({
      type: 'wgs84',
      success: (res) => {
        this.setData({
          hasMapPermission: true,
          currentLocation: {
            latitude: res.latitude,
            longitude: res.longitude
          }
        });
        
        this.reverseGeocoding(res.latitude, res.longitude);
      },
      fail: (error) => {
        console.error('获取位置失败:', error);
      }
    });
  },

  // 逆地址解析
  reverseGeocoding(latitude, longitude) {
    // 暂时使用简单的坐标显示，避免SDK兼容性问题
    const coordStr = `${latitude.toFixed(4)}, ${longitude.toFixed(4)}`;
    this.setData({
      currentAddress: `位置: ${coordStr}`
    });
  },

  // 设置初始地图
  setupInitialMap() {
    console.log('设置初始地图，当前位置:', this.data.currentLocation);
    
    const initialPoint = {
      latitude: this.data.currentLocation.latitude,
      longitude: this.data.currentLocation.longitude,
      speed: 0,
      timestamp: Date.now()
    };
    
    console.log('初始地图点:', initialPoint);
    
    this.updateMapMarkersAndPolyline(initialPoint, [initialPoint]);
    
    // 确保地图缩放级别合适
    this.setData({
      mapScale: 16 // 适合城市级别的缩放
    });
  },

  // 请求位置权限
  requestLocation() {
    wx.authorize({
      scope: 'scope.userLocation',
      success: () => {
        this.setData({ hasMapPermission: true });
        this.getCurrentLocation();
        wx.showToast({
          title: '权限获取成功',
          icon: 'success'
        });
      },
      fail: () => {
        wx.showModal({
          title: '位置权限',
          content: '需要位置权限才能使用地图功能，请在设置中开启',
          showCancel: false
        });
      }
    });
  },

  // 地图控制方法
  zoomIn() {
    const mapScale = Math.min(this.data.mapScale + 1, 20);
    this.setData({ mapScale });
  },

  zoomOut() {
    const mapScale = Math.max(this.data.mapScale - 1, 3);
    this.setData({ mapScale });
  },

  centerMap() {
    // 使用传感器数据中的位置，如果没有则使用当前位置
    let latitude = this.data.currentLocation.latitude;
    let longitude = this.data.currentLocation.longitude;
    
    if (this.data.sensorData.Latitude && this.data.sensorData.Longitude) {
      latitude = this.data.sensorData.Latitude;
      longitude = this.data.sensorData.Longitude;
    }
    
    console.log('居中地图到位置:', { latitude, longitude });
    
    this.setData({
      currentLocation: {
        latitude: latitude,
        longitude: longitude
      }
    });
  },

  clearTrack() {
    wx.showModal({
      title: '清空轨迹',
      content: '确定要清空所有轨迹记录吗？',
      success: (res) => {
        if (res.confirm) {
          this.setData({
            trackPoints: [],
            recentPoints: [],
            polyline: [],
            totalDistance: 0,
            trackingDuration: 0,
            startTime: Date.now()
          });
          
          wx.showToast({
            title: '轨迹已清空',
            icon: 'success'
          });
        }
      }
    });
  },



  // 开始追踪
  startTracking() {
    this.setData({
      trackingActive: true,
      startTime: Date.now()
    });
  },

  // 地图区域变化
  onRegionChange(e) {
    if (e.type === 'end') {
      this.setData({
        mapScale: e.detail.scale || this.data.mapScale
      });
    }
  },

  // 更新时间
  updateTime() {
    const now = new Date();
    const timeString = now.toLocaleTimeString('zh-CN', {
      hour12: false,
      hour: '2-digit',
      minute: '2-digit',
      second: '2-digit'
    });
    
    this.setData({
      currentTime: timeString
    });
  },

  // 启动时间定时器
  startTimeTimer() {
    this.timeTimer = setInterval(() => {
      this.updateTime();
    }, 1000);
  },

  // 清理资源
  cleanup() {
    if (this.timeTimer) {
      clearInterval(this.timeTimer);
      this.timeTimer = null;
    }
  },

  // 车辆模拟控制函数
  toggleVehicleSimulation() {
    console.log('切换车辆模拟状态');
    const current = this.data.vehicleSimulation.isMoving;
    this.setData({
      'vehicleSimulation.isMoving': !current
    });
    wx.showToast({
      title: !current ? '模拟启动' : '模拟暂停',
      icon: 'success'
    });
  },

  restartSimulation() {
    console.log('重置模拟');
    this.setData({
      'vehicleSimulation.isMoving': false,
      'vehicleSimulation.currentRouteIndex': 0
    });
    wx.showToast({
      title: '模拟已重置',
      icon: 'success'
    });
  },

  changeSpeed() {
    console.log('切换速度');
    const speeds = ['慢速', '普通速度', '快速'];
    const currentIndex = speeds.indexOf(this.data.speedText);
    const nextIndex = (currentIndex + 1) % speeds.length;
    this.setData({
      speedText: speeds[nextIndex]
    });
    wx.showToast({
      title: `已切换至${speeds[nextIndex]}`,
      icon: 'success'
    });
  }
}); 